package com.itheima.leetcode.od.b.graph;

import java.util.Arrays;
import java.util.stream.Collectors;

/**
 * <h3>顺时针螺旋数组矩阵</h3>
 * 疫情期间，小明隔离在家，百无聊赖，在纸上写数字玩。他发明了一种写法:
 * <p>
 * 给出数字个数n和行数m(1 < n,m < 999)，从左上角的1开始，按照顺时针螺旋向内写方式，依次写出2,3...n,最终形成个一m行矩阵。
 * <p>
 * 小明对这个矩阵有些要求
 * <p>
 * <p>
 * 1.每行数字的个数一样多
 * <p>
 * 2.列的数量尽可能少
 * <p>
 * 3.填充数字时优先填充外部
 * <p>
 * 4.数字不够时，使用单个*号占位
 * <p>
 * 输入描述
 * <p>
 * 输入一行，两个整数，空格隔开，依次表示n、m
 * <p>
 * 输出描述
 * <p>
 * 符合要求的唯一矩阵
 * <p>
 * <p>
 * 示例1：
 * <p>
 * 输入
 * <p>
 * 9 4
 * <p>
 * 输出
 * <p>
 * 1 2 3
 * <p>
 * * * 4
 * <p>
 * 9 * 5
 * <p>
 * 8 7 6
 * <p>
 * 示例2：
 * <p>
 * 输入
 * <p>
 * 3 5
 * <p>
 * 输出
 * <p>
 * 1
 * <p>
 * 2
 * <p>
 * 3
 * <p>
 * *
 * <p>
 * *
 */
public class SpiralArrayMatrix {
    public static void main(String[] args) {
        /*Scanner in = new Scanner(System.in);
        int[] params = split(in.nextLine(), " ");*/

        String input_str = "9 4";
        int[] params = Arrays.stream(input_str.split(" "))
                .mapToInt(Integer::parseInt)
                .toArray();
        int k = params[0];
        int n = params[1];

        System.out.println(getResult(k, n));
    }

    static int[][] offsets = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}}; // 右 下 左 上

    /**
     * @param k
     * @param n
     * @return
     */
    public static String getResult(int k, int n) {
        String[][] matrix = new String[n][(k + n - 1) / n]; // 向上取整
        Arrays.stream(matrix).forEach(arr -> Arrays.fill(arr, "*"));

        int start_x = 0;
        int start_y = 0;
        int count = 1;
        int index = 0;

        while (count <= k) {
            matrix[start_x][start_y] = String.valueOf(count);
            count += 1;
            int new_x = start_x + offsets[index][0];
            int new_y = start_y + offsets[index][1];


            if (new_x < 0 || new_x >= n || new_y < 0 || new_y >= (k + n - 1) / n
                    || !matrix[new_x][new_y].equals("*")) {
                index = (index + 1) % 4;
                start_x = start_x + offsets[index][0];
                start_y = start_y + offsets[index][1];
            } else {
                start_x = new_x;
                start_y = new_y;
            }
        }

        return Arrays.stream(matrix)
                .map(arr -> Arrays.stream(arr)
                        .collect(Collectors.joining(" ")))
                .collect(Collectors.joining("\n"));
    }
}